package com.ang.mybatisplus.sensitive.controller;


import com.ang.mybatisplus.sensitive.domain.SensitiveUser;
import com.ang.mybatisplus.sensitive.dto.SensitiveUserDTO;
import com.ang.mybatisplus.sensitive.mapper.SensitiveUserMapper;
import com.ang.mybatisplus.sensitive.service.SensitiveUserService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author ssang
 * @since 2022-10-15
 */
@RestController
@RequestMapping("/sensitive")
public class SensitiveQueryController {
    @Autowired
    private SensitiveUserService sensitiveUserService;
    @Resource
    private SensitiveUserMapper sensitiveUserMapper;

    /**
     * 入参是实体类的时候，才可以使用注解和拦截器来加密，使用eq、map、String之类参数，虽然能拦截，但是获取不到@SensitiveField注解，无法判断是否需要解析
     * 出参是实体类的时候，才可以使用注解和拦截器来解密
     *
     * 1、使用service和mapper自带接口，参数实体只能是Domain，不能是DTO
     * 2、使用mapper接口和使用service接口一样
     * 3、如果遇到一些特殊情况，比如自定xml使用了分页插件，会使得第二次查询参数变为Map，可以考虑如下：
     *      在Mapper接口，添加@Param("crypt")注解，这样拦截器中会拦截到crypt参数，但是参数类型必须是object
     */

    //================以下情况，可以使用拦截器、对象加入接的方式，来加解密===============
    /**
     * 框架接口，QueryWrapper，Domain入参，Domain出参
     * 拦截器  MapperMethod.ParamMap类型，get("ew")，getEntity为domain
     */
    @RequestMapping("/queryWrapperDomain")
    public List<SensitiveUser> queryWrapperDomain(){
        SensitiveUser user = new SensitiveUser();
        user.setName("张三");

        return sensitiveUserService.list(new QueryWrapper<>(user));
    }

    /**
     * 框架接口，QueryWrapper，Domain入参，PageHelper分页
     * 第一次SQL：
     *      拦截器  MapperMethod.ParamMap类型，get("ew")，getEntity为domain
     * 第二次SQL：
     *      拦截器  HashMap类型，get("ew")，getEntity为domain
     */
    @RequestMapping("/queryWrapperDomainPage")
    public List<SensitiveUser> queryWrapperDomainPage(){
        SensitiveUser user = new SensitiveUser();
        user.setName("张三");

        PageHelper.startPage(1, 10);

        return sensitiveUserService.list(new QueryWrapper<>(user));
    }

    /**
     * 框架接口，QueryWrapper，Domain入参，IPage分页
     * 拦截器  MapperMethod.ParamMap类型，get("ew")，getEntity为domain
     */
    @RequestMapping("/queryWrapperDomainIPage")
    public List<SensitiveUser> queryWrapperDomainIPage(){
        SensitiveUser user = new SensitiveUser();
        user.setName("张三");

        Page page = new Page<>(2,1);
        IPage ipage = sensitiveUserService.page(page, new QueryWrapper<>(user));

        return ipage.getRecords();
    }

    /**
     * 自定义接口（xml编写SQL语句），Domain入参，Domain出参
     * 拦截器  实体类，domain
     */
    @RequestMapping("/queryXmlDomain")
    public List<SensitiveUser> queryXmlDomain(){
        SensitiveUser user = new SensitiveUser();
        user.setName("张三");

        return sensitiveUserService.listByDomainReturnDomain(user);
    }

    /**
     * 自定义接口，DTO入参，DTO出参
     * 拦截器  就是一个dto
     */
    @RequestMapping("/queryXmlDto")
    public List<SensitiveUserDTO> queryXmlDto(){
        SensitiveUserDTO dto = new SensitiveUserDTO();
        dto.setName("张三");

        return sensitiveUserService.listByDtoReturnDto(dto);
    }

    /**
     * 自定义接口，Domain入参，Domain出参，PageHelper分页
     * 第一次拦截    是个ew
     * 第二次拦截    是个map
     */
    @RequestMapping("/queryXmlDomainPage")
    public List<SensitiveUser> queryXmlDomainPage(){
        SensitiveUser user = new SensitiveUser();
        user.setName("张三");

        PageHelper.startPage(1, 1);

        return sensitiveUserService.queryXmlDomainPage(user);
    }

    /**
     * 自定义接口，Domain入参，Domain出参，IPage分页
     * 第一次拦截    是个ew
     * 第二次拦截    是个map
     */
    @RequestMapping("/queryXmlDomainIPage")
    public List<SensitiveUser> queryXmlDomainIPage(){
        SensitiveUser user = new SensitiveUser();
        user.setName("张三");

        Page<SensitiveUser> page = new Page<>(1,1);
        IPage ipage = sensitiveUserService.queryXmlDomainIPage(page, user);

        return ipage.getRecords();
    }



    //================以下情况，只能自己手动给参数加密===============

    /**
     * 框架接口，QueryWrapper，eq等构造器入参，Domain出参
     * 拦截器  ew，entity为null
     */
    @RequestMapping("/queryWrapperEq")
    public List<SensitiveUser> queryWrapperEq(){
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("name","张三");

        return sensitiveUserService.list(queryWrapper);
    }

    /**
     * 框架接口，Map入参，Domain出参
     * 拦截器  cm，cm的值，就是传入的map
     */
    @RequestMapping("/queryWrapperMap")
    public List<SensitiveUser> queryWrapperMap(){
        Map<String, Object> map = new HashMap<>();
        map.put("name","张三");

        return sensitiveUserService.listByMap(map);
    }

    /**
     * 自定义接口，Map入参，Map出参
     * 拦截器  就是一个map
     */
    @RequestMapping("/queryXmlMap")
    public List<Map> queryXmlMap(){
        Map<String, String> map = new HashMap<>();
        map.put("name","张三");

        return sensitiveUserService.listByMapReturnMap(map);
    }

}
